/**
 * WebSocket 连接管理工具
 * 用于用户-客服聊天系统实时通信
 */

class WebSocketManager {
  constructor() {
    this.ws = null
    this.clientId = null
    this.clientName = null
    this.reconnectAttempts = 0
    this.maxReconnectAttempts = 5
    this.reconnectDelay = 3000 // 3秒
    this.isConnecting = false
    this.messageHandlers = new Set()
  }

  /**
   * 连接 WebSocket
   * @param {string} clientId - 客户端ID（用户ID）
  * @param {string} nickname - 客户端昵称（用户名）
   */
  connect(clientId, nickname = '') {
    console.warn('[WebSocket] 实时客服功能未启用，跳过连接')
    return

    if (this.isConnecting || (this.ws && this.ws.readyState === WebSocket.OPEN)) {
      console.log('[WebSocket] 已连接或正在连接中')
      return
    }

    if (!clientId) {
      console.error('[WebSocket] clientId 不能为空')
      return
    }

    this.clientId = clientId
    this.clientName = nickname || `用户${clientId}`
    this.isConnecting = true
    this.reconnectAttempts = 0

    try {
      // 新后端路由：/ws/{client_id}?nickname=用户名
      const wsUrl = `ws://127.0.0.1:8002/ws/${clientId}?nickname=${encodeURIComponent(this.clientName)}`
      console.log(`[WebSocket] 正在连接: ${wsUrl}`)
      
      this.ws = new WebSocket(wsUrl)

      this.ws.onopen = () => {
        console.log(`[WebSocket] 连接成功: client_id=${clientId}, nickname=${this.clientName}`)
        this.isConnecting = false
        this.reconnectAttempts = 0
        this.onConnected()
      }

      this.ws.onmessage = (event) => {
        console.log(`[WebSocket] 收到消息:`, event.data)
        this.handleMessage(event.data)
      }

      this.ws.onerror = (error) => {
        console.error('[WebSocket] 连接错误:', error)
        this.isConnecting = false
      }

      this.ws.onclose = () => {
        console.log('[WebSocket] 连接关闭')
        this.isConnecting = false
        this.ws = null
        
        // 自动重连（仅在非手动关闭时）
        if (this.clientId && this.reconnectAttempts < this.maxReconnectAttempts) {
          this.reconnectAttempts++
          console.log(`[WebSocket] ${this.reconnectDelay/1000}秒后尝试重连 (${this.reconnectAttempts}/${this.maxReconnectAttempts})`)
          setTimeout(() => {
            this.connect(this.clientId, this.clientName)
          }, this.reconnectDelay)
        }
      }
    } catch (error) {
      console.error('[WebSocket] 连接异常:', error)
      this.isConnecting = false
    }
  }

  /**
   * 断开连接
   */
  disconnect() {
    console.log('[WebSocket] 手动断开连接')
    this.clientId = null
    this.clientName = null
    this.reconnectAttempts = this.maxReconnectAttempts // 阻止自动重连
    
    if (this.ws) {
      this.ws.close()
      this.ws = null
    }
    
    this.messageHandlers.clear()
  }

  /**
   * 发送消息（原始方法，发送字符串）
   */
  send(message) {
    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
      this.ws.send(message)
      return true
    } else {
      console.warn('[WebSocket] 连接未打开，无法发送消息')
      return false
    }
  }

  /**
   * 新协议：发送消息
   * @param {string} to - 目标 client_id
   * @param {string} content - 文本内容
   */
  sendTo(to, content) {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      console.warn('[WebSocket] 连接未打开，无法发送消息')
      return false
    }
    const payload = { to, content }
    try {
      this.ws.send(JSON.stringify(payload))
      console.log(`[WebSocket] 发送消息 -> ${to}: ${content}`)
      return true
    } catch (error) {
      console.error('[WebSocket] 发送消息失败:', error)
      return false
    }
  }

  // 兼容旧方法：转换为 sendTo
  sendChatMessage(_user_id, auth_id, content) {
    return this.sendTo(auth_id, content)
  }

  /**
   * 添加消息处理器
   */
  onMessage(handler) {
    this.messageHandlers.add(handler)
    
    // 返回取消监听的函数
    return () => {
      this.messageHandlers.delete(handler)
    }
  }

  /**
   * 处理收到的消息
   */
  handleMessage(data) {
    try {
      // 解析JSON消息
      let message
      try {
        message = JSON.parse(data)
      } catch {
        // 如果不是JSON，作为纯文本处理
        message = { type: 'text', content: data }
      }

      // 根据后端返回的消息格式处理
      // 后端返回格式：
      // - 聊天消息: {type: 'chat', from, from_nickname, content, time}
      // - 系统消息: {type: 'system', message}
      // - 成功/错误: {type: 'success'|'error', message, time?}
      console.log('[WebSocket] 收到消息:', message)

      // 通知所有处理器
      this.messageHandlers.forEach(handler => {
        try {
          handler(message)
        } catch (error) {
          console.error('[WebSocket] 消息处理器执行失败:', error)
        }
      })
    } catch (error) {
      console.error('[WebSocket] 处理消息失败:', error)
    }
  }

  /**
   * 连接成功回调
   */
  onConnected() {
    // 可以在这里发送初始消息或做其他初始化
    console.log('[WebSocket] 连接已建立，可以接收消息')
  }

  /**
   * 获取连接状态
   */
  get isConnected() {
    return this.ws && this.ws.readyState === WebSocket.OPEN
  }
}

// 导出单例
export const wsManager = new WebSocketManager()

// 默认导出
export default wsManager

